import json
import random
import time
import redis
import requests
from flask import Blueprint, send_file, make_response, redirect
from flask_restful import reqparse
from ronglian_sms_sdk import SmsSDK
from tools.my_jwt import jj
from app import db
from tools.captcha.captcha import captcha
from tools.comm import sendMsg , get_ali_object
from tools.myredis import r
from application.models.users.user import *
from flask import Blueprint,request,jsonify

user_blue = Blueprint("userblue",__name__)
from captcha.image import ImageCaptcha

@user_blue.route('/text')
def get():
    return jsonify({'code':200,'msg':'mes'})



@user_blue.route('/getcode')
def get_img():
    name,text,img=captcha.generate_captcha()
    uuid=request.args.get('uuid')
    r.str_add(uuid,text)
    cls = redis.Redis(host='127.0.0.1')
    print(">>>>>>>>>>>>>>>>",cls.get(uuid))
    res=make_response(img)
    res.headers['Content-Type']="image/jpg"
    return res



@user_blue.route('/sendSmsCode',methods=['POST'])
def sendSmsCode():
    data = request.data
    if data:
        # 获取3个参数
        data = json.loads(data)
        uuid = data['uuid']
        piccode = data['piccode']
        print(piccode,'>>>>>>>>>>>>>>>>')
        mobile = data['mobile']
        # redis中获取图片验证码
        value = r.str_get(uuid)
        # 对redis中获取的图片验证码解析
        value1 = value.decode()
        print(value1)
        # 如果图片验证码存在
        if value:
            # 将前端输入的验证码和图片验证码转为大小写 做对比
            if piccode.lower()==value1.lower():
                # 把redis里面存的手机号获取出来 然后赋值给mcode
                mcode = r.str_get(mobile)
                # 如果手机号存在
                if mcode:
                    return jsonify({'code':10012,'msg':'一分钟内不能重复发'})
                # 调用random生成随机数
                scode = random.randint(10000,99999)
                # 把容连云赋值到flag里面
                flag = sendMsg(mobile,scode)
                # 如果flag存在
                if flag:
                    # 就把手机号加入到redis里面 一分钟
                    r.str_setex(mobile,scode,60)
                    # 判断完图形验证码之后 删除redis里面的图形验证码
                    r.del_key(uuid)
                    return jsonify({'code':200,'msg':'发送成功'})
                else:
                    return jsonify({'code':10013,'msg':'发送验证码错误'})
            else:
                return jsonify({'code':10011,'msg':'图片验证码错误'})

        else:
            return jsonify({'code':10010,'msg':'图片验证码不存在'})


@user_blue.route('/login',methods=['POST'])
# 注册登录接口
def login():
    # 获取前端返回的数据
    data = request.data
    # 如果存在
    if data:
        # 把获取到的data 转化json格式赋值到data里面
        data = json.loads(data)
        # 获取参数
        mcode = data['code']
        mobile = data['mobile']
        # 获取到redis里面存储的手机号
        code = r.str_get(mobile)
        # 如果手机号存在
        if code:
            #
            if int(code)==int(mcode):
                user = User.query.filter(User.mobile==mobile).first()
                if user:
                    r.del_key(mobile)
                else:
                    u = User(mobile=mobile,nikename=mobile)
                    db.session.add(u)
                    db.session.commit()
                    user = User.query.filter(User.mobile==mobile).first()
                # 用户信息生成jwt token
                token = jj.jwt_encode(data={'data':{'uid':user.id,'exp':int(time.time())}})
                return jsonify({'code':200,'token':token,'userid':user.id})
            else:
                return jsonify({'code':10021,'msg':'验证码错误'})
        else:
            return jsonify({'code':10020,'msg':''})

# 获取weibo地址
@user_blue.route('/sf_login')
def getwburl():
    client_id = "3674019597"
    redirect_uri = "http://127.0.0.1:8000/user/weiboCallback/"
    url = "https://api.weibo.com/oauth2/authorize?client_id=%s&redirect_uri=%s&response_type=code" % (
        client_id, redirect_uri)
    return jsonify({"code":200,"url":url})

# weibo回调接口
@user_blue.route('/user/weiboCallback/')
def weiboCallback():
    # 获取code
    code = request.args.get("code")
    # 向access_token接口发送post请求
    data = {"client_id": '3674019597', "client_secret": "7ae99bc0d54ead29fc8d1b9fabd78587",
            "grant_type": "authorization_code",
            'redirect_uri': 'http://127.0.0.1:8000/user/weiboCallback/', 'code': code}
    res = requests.post('https://api.weibo.com/oauth2/access_token', data=data)
    # 根据返回结果操作
    # 获取token和uid
    message = json.loads(res.text)
    token = message['access_token']
    uid = message['uid']
    # 查询数据库中是否存在，如果存在用户信息生成jwt token 返回
    sql = 'select user.id from user inner join sf_login on user.id=sf_login.userid where sf_login.uid=%s'%(uid)
    user = db.session.execute(sql)
    if user:
        for i in user:
            data = {'data':{'userid':i[0],'exp':int(time.time())}}
            token = jj.jwt_encode(data)
            return redirect("http://localhost:8080/#/updateToken?userid="+str(i[0]) + "&token=" + token)
    # 不存在跳转到vue绑定页面，token uid 传递过去
    return redirect("http://localhost:8080/#/banding?uid="+uid+"&token="+token)

# 绑定手机号
@user_blue.route('/bandMobile',methods=['POST'])
def bandMobile():
    data = json.loads(request.data)
    mobile = data['mobile']
    uid = data['uid']
    token = data['token']
    print(mobile,'>>>>>>>>>>>>>>>>>>>>>>>>>..')
    # 先查询用户表，如果手机号存在，获取userid,写入三方登录表，生成token返回
    user = User.query.filter(User.mobile==mobile).first()
    print(user)
    if not user:
        # 添加用户
        u = User(mobile=mobile,nikename=mobile)
        print(u)
        db.session.add(u)
        db.session.commit()
        # 获取用户信息
        user = User.query.filter(User.mobile==mobile).first()
    sfuser = SfLogin(userid=user.id, webfrom='wb', uid=uid, token=token)
    db.session.add(sfuser)
    db.session.commit()
    # 如果不存在，写入user表
    # 获取userid,写入三方登录表，生成token返回
    data = {'data':user.id,'exp':int(time.time())}
    token = jj.jwt_encode(data)
    return jsonify({'userid':str(user.id),'token':token})


# 测试
@user_blue.route("/test")
def test():
    orderon = 123455
    pay = get_ali_object()
    query_params = pay.direct_pay(
        subject='test' + "充值服务",  # 商品简单描述
        out_trade_no=orderon,  # 用户购买的商品订单号（每次不一样） 20180301073422891
        total_amount=float(1.00),  # 交易金额(单位: 元 保留俩位小数)
    )
    pay_url = "https://openapi.alipaydev.com/gateway.do?{0}".format(query_params)  # 支付宝网关地址（沙箱应用）
    return jsonify({
        'code': 200,
        'url': pay_url
    })

@user_blue.route('/buy',methods=['POST'])
def buy():
    # 获取参数
    data = json.loads(request.data)
    userid = data['userid']
    year = data['year']
    money = 200
    # 生成订单
    tmoney = money * int(year)
    order_no = str(int(time.time()))+str(userid)+str(random.randint(100,999))
    Viprecord = VipRecord(order_no=order_no,userid=userid,year=year,money=tmoney,active_money=tmoney,status=1)
    db.session.add(Viprecord)
    db.session.commit()
    pay = get_ali_object()
    query_params = pay.direct_pay(
        subject='test',  # "充值服务",  # 商品简单描述
        out_trade_no=str(order_no),  # 用户购买的商品订单号（每次不一样） 20180301073422891
        total_amount=float(1.00),  # 交易金额(单位: 元 保留俩位小数)
    )
    pay_url = "https://openapi.alipaydev.com/gateway.do?{0}".format(query_params)  # 支付宝网关地址（沙箱应用）
    return jsonify({
        'code': 200,
        'url': pay_url
    })
    #支付返回url

import datetime
@user_blue.route("/callback")
def callback():
    # 接受参数
    data = request.args
    datames = {k:v for k, v in data.items()}
    sign = datames.pop('sign')
    pay = get_ali_object()
    flag = pay.verify(datames,sign)
    print(flag)
    if flag==True:
        order_no = datames['trade_no']
        #支付宝流水号
        transaction_no =datames['out_trade_no']
        # 事务处理
        try:
            # 更新订单表
            record = VipRecord.query.filter(VipRecord.order_no == order_no).first()
            record.status = 2
            record.transaction_no = transaction_no
            db.session.add(record)
            # 更新用户表
            User.query.filter(User.id == record.userid).updata({"level":2})
            # 更新vip表
            vip = Vip.query.filter(Vip.userid==record.userid,status = 1).first()
            if vip is not None:
                #结束时间+购买年限
                etime = vip.e_time.split("-")
                year =int(etime[0])+int(record.year)
                vip = Vip(userid = record.userid,s_time=datetime.datetime.now(),e_time = year)
                db.session.add(vip)
            db.session.ommit()
        except:
            db.session.rollback()
    else:
        print("鉴权失败")
    return 'ok'

# 添加课程使用，获取标签，分类，类别
@user_blue.route("/gettags")
def gettags():
    tags=Tags.query.all()
    tagslist=[{"id":i.id,"name":i.name} for i in tags]
    types=Ctype.query.all()
    typelist=[{"id":i.id,"name":i.name} for i in types]
    ctype=CourseType.query.all()
    clist=[{"id":i.id,"name":i.name} for i in ctype]
    return jsonify({"code":200,"tags":tagslist,"types":typelist,"clist":clist})


from qiniu import Auth
@user_blue.route("/get_qntoken")
def get_qntoken():
    #需要填写你的 Access Key 和 Secret Key
    access_key = 'oTzCS4G6GJ3Xav4R_PgCxN3PVQp815BWcsuI1Dhy'
    secret_key = 'amnWrU9vONfg88dYGesWDo3GcYNNNb3mmhMVTzos'
    #构建鉴权对象
    q = Auth(access_key, secret_key)
    #要上传的空间
    bucket_name = 'p10086'
    #3600为token过期时间，秒为单位。3600等于一小时
    token=q.upload_token(bucket_name)
    return jsonify({"code":200,'token':token})

# 添加课程
@user_blue.route('/addCourse',methods=['POST'])
def addCourse():
    try:
      #获取参数
      data = json.loads(request.data)
      #写入课程表
      course = Course(name = data['name'],url=data['url'],descrip=data['desc'],ctype= data['type'])
      db.session.add(course)
      #获取新加的课程的id
      scourse = Course.query.filter(Course.name ==data['name']).first()
      #写入课程标签表
      for i in data['tags']:
          sql = "insert into course_tag(courseid, tagid) values (%d,%d)"%(scourse.id,int(i))
          db.session.execute(sql)
      #课程分类表
      for i in data['ctype']:
          sql = "insert into course_cate(courseid, course_typeid) values (%d,%d)"%(scourse.id,int(i))
          db.session.execute(sql)
      db.session.commit()
      # return 'ok'
    except:
        db.session.rollback()
    return jsonify({'code':200})



# import math
# # 分页
# @user_blue.route('/getCourse')
# def getCourse():
#         #获取参数page
#         page = int(request.args.get("page"))
#         #获取上线，即将上线条件
#         online = int(request.args.get("is_publish"))
#         #查询总条数
#         total = Course.query.filter(Course.is_publish == online).count()
#         #定义每页显示多少条
#         page_size = 2
#         #查询当前页记录
#         start = math.ceil((page-1)*page_size)
#         orderpara = request.args.get('orderpara')
#         # select * from coourse limit start,page_size
#         #获取排序字段
#         if orderpara == 'new':
#             course = Course.query.order_by(Course.create_time.desc()).filter(Course.is_publish == online).offset(start).limit(page_size).all()
#         else:
#             course = Course.query.order_by(Course.views.desc()).filter(Course.is_publish == online).offset(start).limit(page_size).all()
#         list = [{"id":i.id,"name":i.name,"url":i.url,"views":i.views} for i in course]
#         return jsonify({"code":200,"clist":list,"total":total,"page_size":page_size})




# @user_blue.route("/getCourse")
# def getCourse():
#     #获取当前页面
#     page = request.args.get('page')
#     #获取条件
#     #获取上线,即将上线条件
#     online = int(request.args.get('is_publish'))
#     #获取类别
#     types = int(request.args.get('types'))
#     #获取类别
#     tags = int(request.args.get('tags'))

from tools.sms import get_ali_object


#添加购物车
@user_blue.route("/addcart",methods=['POST'])
def addcart():
    data = reqparse.RequestParser()
    data.add_argument("userid")
    data.add_argument("goodsid")
    args = data.parse_args()
    userid = int(args["userid"])
    goodsid = int(args["goodsid"])
    # pkey = "mycart" + str(userid)
    # r.hash_add(pkey,goodsid,userid)
    # return jsonify({"code":200,"msg":"添加购物车成功"})
    pkey = "mycart"+str(userid)
    r.hash_add(pkey,goodsid,userid)
    return jsonify({"code":200,"msg":"加入购物车成功"})

from flask_restful import reqparse

# 我的购物车
@user_blue.route("/getcart")
def getcart():
    userid = request.args.get("userid")
    pkey = "mycart"+str(userid)
    print(pkey)
    res = r.hash_getall(pkey)
    print(">>>",res)
    cartlist = []
    for i,j in res.items():
        goodsid = i.decode()
        sql = "select id,name,price,url from course where id=%d"%int(goodsid)
        res = db.session.execute(sql)
        for i in res:
            cartlist = {"id":i["id"],"name":i["name"],"price":i["price"],"url":i["url"]}
        print(cartlist)
        return jsonify({"code": 200, "msg":"ok","cartlist": cartlist})





@user_blue.route("/pay",methods=["POST"])
def pay():
    data=json.loads(request.data)
    userid=int(data["userid"])
    courseid=int(data["courseid"])
    sum=0
    sql = "select * from course where id=%d" % courseid
    print(sql)
    res=db.session.execute(sql)
    print("res>>",res)
    for i in res:
        cartlist = {"id": i['id'],
        "create_time": i['create_time'],
        "update_time": i['update_time'],
        "name": i['name'],
        "url": i['url'],
        "descrip": i['descrip'],
        "tcount": i['tcount'],
        "views": i['views'],
        "is_publish": i['is_publish'],
        "ctype": i['ctype'],
        "buy": i['buy'],
        "price":i["price"]}
    print(cartlist)
    sum+=float(cartlist["price"])
    # 订单号
    number = int(str(int(time.time())) + str(userid) + str(random.randint(1000, 9999)))
    create_time = datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S")
    update_time = datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S")
    status = 2
    try:
        usql = vipuser_course(courseid=courseid,userid=userid)
        db.session.add(usql)
        print(usql.userid,usql.courseid,"oooooo")
        isql = Orders(create_time=create_time,update_time=update_time,userid=userid,courseid=courseid,number=number,tmoney=sum,status=status)
        db.session.add(isql)
        db.session.commit()
    except:
        db.session.rollback()
    # 支付
    alipay = get_ali_object()
    query_params = alipay.direct_pay(
        subject=str(userid) + "购买课程",  # 商品简单描述
        out_trade_no=number,  # 用户购买的商品订单号（每次不一样） 20180301073422891
        total_amount=sum,  # 交易金额(单位: 元 保留俩位小数)
    )
    pay_url = "https://openapi.alipaydev.com/gateway.do?{0}".format(query_params)  # 支付宝网关地址（沙箱应用）
    return jsonify({
        'code': 200,
        'url': pay_url
    })



# @user_blue.route("/callback")
# def callback():
#     try:
#         sql = "update orders set status=2"
#         db.session.add(sql)
#         db.session.commit()
#     except:
#         db.session.rollback()
#     # 跳转到个人中心
#     return redirect('http://localhost:8080/#/')



#类别
@user_blue.route('/ctype')
def ctype():
    ctypelist = []
    #获取缓存中数据
    r.del_key("ctype")
    ctype = r.str_get("ctype")
    #判断是否存在
    if ctype:
        ctypelist = json.loads(ctype)
    else:
        sql = Ctype.query.all()
        for i in sql:
            d = {
                "id":i.id,
                "name":i.name
            }
            ctypelist.append(d)
        #存入缓存
        r.set_str("ctype",json.dumps(ctypelist))
    return ctypelist

# 标签
def getTaglist():
    taglist = []
    r.del_key("tage")
    tag = r.str_get("tage")
    if tag:
        taglist = json.loads(tag)
    else:
        sql = Tags.query.all()
        for i in sql:
            d = {
                "id":i.id,
                "name":i.name
            }
            taglist.append(d)
        r.set_str("tage", json.dumps(taglist))
    return taglist
#分页
@user_blue.route("/getHomeGourse")
def getHomeGourse1():
    # 获取类型
    ctypelist = ctype()
    # 获取标签
    taglist = getTaglist()
    # 获取当前页面
    page = request.args.get("page")
    # 获取查询条件
    typeid = request.args.get("type")
    tagid = request.args.get("tagid")
    online = request.args.get("online")
    # 排序条件
    orderbyid = request.args.get("orderbyid")
    where = ""
    if int(typeid) > 0:
        where = where + " and c.ctype=" + typeid

    if int(online) > 0:
        where = where + " and c.views=" + online

    # res = db.session.execute("select * from user where id=1")
    # print(res.fetchall())
    # print(res.fetchone())

    if int(tagid) > 0:
        tsql = "select count(c.id) as tcount from course as c inner join course_tag as cl on cl.courseid=tcount where cl.tagid=" + tagid
        sql = "select * from course as c inner join course_tag as cl on cl.courseid=c.id  where cl.tagid=" + tagid
    else:
        sql = "select * from course as c where 1=1"
        tsql = "select count(c.id) as tcount from course as c  where 1=1"

    if where:
        sql = sql + " " + where
        tsql = tsql + " " + where

    if int(orderbyid) > 0:
        if int(orderbyid) == 1:
            sql = sql + " order by c.id desc"
        else:
            sql = sql + " order by c.is_publish desc"

    # 查询总共有多少条
    tsql = db.session.execute(tsql)
    total = 0
    for i in tsql:
        total = i[0]

    page_size = 2
    start = (int(page) - 1) * page_size
    clist = sql + " limit %d,%d" % (start,page_size)
    clist = db.session.execute(clist)
    courselist = []
    # print(courselist)
    # print(clist)
    for i in clist:
        d = {
            "id":i[0],
            "create_time":i[1],
            "update_time":i[2],
            "name":i[3],
            "url":i[4],
            "descrip":i[5],
            "tcount":i[6],
            "views":i[7],
            "is_publish":i[8],
            "ctype":i[9],
            "buy":i[10]
        }
        courselist.append(d)

    return jsonify({"code": 200, "tlist": ctypelist, 'taglist': taglist, 'clist': courselist, "total": total,
                    "page_size": page_size})


# 课程详情页面
@user_blue.route("/detail")
def detail():
    # 获取课程id
    id = request.args.get('id')
    # 从缓存中查询课程及章节信息
    key = "course"+str(id)
    skey = "jie"+str(id)
    r.del_key(key)
    r.del_key(skey)
    course = r.str_get(key)
    if course:
        print("缓存")
        jie = r.str_get(skey)
        return jsonify({"code": 200, 'clist': json.loads(course), 'slist': json.loads(jie)})
    # 如果存在直接返回，如果不存在查询数据库
    else:
        print("查询")
        sql = "select c.id,j.id as jid,c.name as cname,c.descrip,c.tcount,j.name,j.url,j.type,c.ctype from course as c inner join jie as j on c.id=j.courseid where c.id=%d order by j.tcount asc" % (
            int(id))
        res = db.session.execute(sql)
        jie = []
        course = []
        for i in res:
            # 获取课程下所有的章节
            d = {
                "id": i['jid'], "name": i['name'], "url": i['url'], "courseid": i['id'], "type": i['type']
            }
            # 获取课程信息
            c = {
                "id": i['id'], "type": i["ctype"], "name": i['cname'],
                'descrip': i['descrip'], 'tcount': i['tcount']
            }
            jie.append(d)
            course.append(c)
        # 数据解析存入redis
        r.set_str(key, json.dumps(course))
        r.set_str(skey, json.dumps(jie))
        return jsonify({"code": 200, 'clist': course, 'slist': jie})